{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 利用lstm进行生成莫言小说\n",
    "\n",
    "## 1. 项目背景\n",
    "这个项目是建立一个能够自动生成一片文章的深度学习模型，我们可以通过给出钱几个字就自动生成一篇文章的模型。\n",
    "\n",
    "## 2. 项目数据\n",
    "项目数据使用了莫言小说《生死疲劳》，内容如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸(又鸟)一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟……鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ========读取原始数据========\n",
    "with open('data.txt', 'r', encoding='utf-8') as f:\n",
    "    data = f.readlines()\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 数据处理\n",
    "### 3.1数据清洗\n",
    "**首先需要将括号里的内容删除掉。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟……鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "# 生成一个正则，负责找'()'包含的内容\n",
    "pattern = re.compile(r'\\(.*\\)')\n",
    "# 将其替换为空\n",
    "data = [pattern.sub('', lines) for lines in data]\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**然后我们将省略号'......'替换为句号'。'**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "　　我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的 酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的 回声。我身受酷刑而绝不改悔，挣得了一个硬汉子的名声。我知道许多鬼卒对我暗中钦佩，我也知道阎王 老子对我不胜厌烦。为了让我认罪服输，他们使出了地狱酷刑中最歹毒的一招，将我扔到沸腾的油锅里， 翻来覆去，像炸一样炸了半个时辰，痛苦之状，难以言表。鬼卒还用叉子把我叉起来，高高举着， 一步步走上通往大殿的台阶。两边的鬼卒嘬口吹哨，如同成群的吸血蝙蝠鸣叫。我的身体滴油淅沥，落在 台阶上，冒出一簇簇黄烟。鬼卒小心翼翼地将我安放在阎罗殿前的青石板上，跪下向阎王报告：“大王 ，炸好了。”\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 将.....替换为句号\n",
    "data = [line.replace('……', '。') for line in data if len(line) > 1]\n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**只保留有效的数据，包括汉字、字母、数字、中文符号等信息，其他乱码进行清除**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的回声。我身受酷\n"
     ]
    }
   ],
   "source": [
    "# ==============判断char是否是乱码===================\n",
    "def is_uchar(uchar):\n",
    "    \"\"\"判断一个unicode是否是汉字\"\"\"\n",
    "    if uchar >= u'\\u4e00' and uchar<=u'\\u9fa5':\n",
    "            return True\n",
    "    \"\"\"判断一个unicode是否是数字\"\"\"\n",
    "    if uchar >= u'\\u0030' and uchar<=u'\\u0039':\n",
    "            return True       \n",
    "    \"\"\"判断一个unicode是否是英文字母\"\"\"\n",
    "    if (uchar >= u'\\u0041' and uchar<=u'\\u005a') or (uchar >= u'\\u0061' and uchar<=u'\\u007a'):\n",
    "            return True\n",
    "    if uchar in ('，','。','：','？','“','”','！','；','、','《','》','——'):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# 将每行的list合成一个长字符串\n",
    "data = ''.join(data)\n",
    "data = [char for char in data if is_uchar(char)]\n",
    "data = ''.join(data)\n",
    "print(data[:100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 生成字典\n",
    "我们需要将汉字映射为能够输入到模型中的数字信息，就需要建立一个映射关系，需要生成汉字和数字互相映射的字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "字典长度: 3892\n"
     ]
    }
   ],
   "source": [
    "# =====生成字典=====\n",
    "vocab = set(data)\n",
    "id2char = list(vocab)\n",
    "char2id = {c:i for i,c in enumerate(vocab)}\n",
    "\n",
    "print('字典长度:', len(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 转换输入数据格式\n",
    "建立字典后，将文本数据映射为数字数据形式，并整理为矩阵格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数字数据信息：\n",
      " [1508 1597  939  449  335 2258 3376 2603  817   57 1623 3376 1211 3376\n",
      "  446 2973 1281 3666  954 1072 1439 2563  487 1623 2786 1597 2662 1780\n",
      "  951  335 1508  954 3777 3113 3767 2676  951 2696 2246 2116 2585 1780\n",
      " 3169 2807 1440 3291 1597 2752 3127 3666 3308 2938 1999 3348  335 1508\n",
      " 2637 1417 1046 2715 2427  578 3666 1508 1597 1866 1490 2849 3401   58\n",
      " 1622  335 2301 3138 3006 1892  845 3358 1150 1597 3308 2965 2296  808\n",
      "  335 3065  275  722  387  387 2150 2150 1597 1242 1866 3666 1508 1905\n",
      " 2696 2752]\n",
      "\n",
      "文本数据信息：\n",
      " 我的故事，从1950年1月1日讲起。在此之前两年多的时间里，我在阴曹地府里受尽了人间难以想象的酷刑。每次提审，我都会鸣冤叫屈。我的声音悲壮凄凉，传播到阎罗大殿的每个角落，激发出重重叠叠的回声。我身受酷\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# =====转换数据为数字格式======\n",
    "numdata = [char2id[char] for char in data]\n",
    "numdata = np.array(numdata)\n",
    "\n",
    "print('数字数据信息：\\n', numdata[:100])\n",
    "print('\\n文本数据信息：\\n', ''.join([id2char[i] for i in numdata[:100]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 设计数据生成器\n",
    "这篇文章有几十万个字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "377480\n"
     ]
    }
   ],
   "source": [
    "print(len(data))"
   ]
  },
  {
   "attachments": {
    "rnnet.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们通常不会将数据一股脑扔到网络中进行训练，而是将数据分为一个batch一个batch的进行训练。\n",
    "下面的函数实现了将数据切分为一个个的[batch_size, time_steps]形式，这种数据也是循环神经网络训练中使用的格式。\n",
    "通过观察输入数据和输出数据我们发现，输入数据总是比输出数据提前一个time_step。如下图所示：\n",
    "![rnnet.jpg](attachment:rnnet.jpg)\n",
    "这是因为我们要建立的模型实现的功能是希望通过输入：3001 3472 3811 1021  271 能够成功的预测下一个单词：1644"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input data: [1508 1597  939  449  335] \n",
      "output data: [1597  939  449  335 2258]\n"
     ]
    }
   ],
   "source": [
    "# =======设计数据生成器=========\n",
    "def data_generator(data, batch_size, time_stpes):\n",
    "\tsamples_per_batch = batch_size * time_stpes\n",
    "\tbatch_nums = len(data) // samples_per_batch\n",
    "\tdata = data[:batch_nums*samples_per_batch]\n",
    "\tdata = data.reshape((batch_size, batch_nums, time_stpes))\n",
    "\tfor i in range(batch_nums):\n",
    "\t\tx = data[:, i, :]\n",
    "\t\ty = np.zeros_like(x)\n",
    "\t\ty[:, :-1] = x[:, 1:]\n",
    "\t\ttry:\n",
    "\t\t\ty[:, -1] = data[:, i+1, 0]\n",
    "\t\texcept:\n",
    "\t\t\ty[:, -1] = data[:, 0, 0]\n",
    "\t\tyield x, y\n",
    "\n",
    "# 打印输出数据\n",
    "data_batch = data_generator(numdata, 2, 5)\n",
    "x, y = next(data_batch)\n",
    "print('input data:', x[0], '\\noutput data:', y[0])"
   ]
  },
  {
   "attachments": {
    "lstm.jpg": {
     "image/jpeg": "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"
    },
    "rnnet.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 模型选择与建模\n",
    "我们选择rnn来作为文本生成模型结构如下：\n",
    "![rnnet.jpg](attachment:rnnet.jpg)\n",
    "我们选择lstm来做为其中的隐藏层：\n",
    "![lstm.jpg](attachment:lstm.jpg)\n",
    "### 4.1 使用tensorflow进行建模："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.python.layers.core import Dense\n",
    "\n",
    "# ====================================搭建模型===================================\n",
    "class RNNModel():\n",
    "\t\"\"\"docstring for RNNModel\"\"\"\n",
    "\tdef __init__(self, BATCH_SIZE, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE, learning_rate):\n",
    "\t\tsuper(RNNModel, self).__init__()\n",
    "\t\tself.BATCH_SIZE = BATCH_SIZE\n",
    "\t\tself.HIDDEN_SIZE = HIDDEN_SIZE\n",
    "\t\tself.HIDDEN_LAYERS = HIDDEN_LAYERS\n",
    "\t\tself.VOCAB_SIZE = VOCAB_SIZE\n",
    "\t\t\n",
    "\t\t# ======定义占位符======\n",
    "\t\twith tf.name_scope('input'):\n",
    "\t\t\tself.inputs = tf.placeholder(tf.int32, [BATCH_SIZE, None])\n",
    "\t\t\tself.targets = tf.placeholder(tf.int32, [BATCH_SIZE, None])\n",
    "\t\t\tself.keepprb = tf.placeholder(tf.float32)\n",
    "\n",
    "\t\t# ======定义词嵌入层======\n",
    "\t\twith tf.name_scope('embedding'):\n",
    "\t\t\tembedding = tf.get_variable('embedding', [VOCAB_SIZE, HIDDEN_SIZE])\n",
    "\t\t\temb_input = tf.nn.embedding_lookup(embedding, self.inputs)\n",
    "            emb_input = tf.nn.dropout(emb_input, self.keepprb)\n",
    "            emb_input = Dense(HIDDEN_SIZE, use_bias=False)(emb_input)\n",
    "\n",
    "\t\t# ======搭建lstm结构=====\n",
    "\t\twith tf.name_scope('rnn'):\n",
    "\t\t\tlstm = tf.contrib.rnn.LSTMCell(HIDDEN_SIZE, state_is_tuple=True)\n",
    "\t\t\tlstm = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=self.keepprb)\n",
    "\t\t\tcell = tf.contrib.rnn.MultiRNNCell([lstm] * HIDDEN_LAYERS)\n",
    "\t\t\tself.initial_state = cell.zero_state(BATCH_SIZE, tf.float32)\n",
    "\t\t\toutputs, self.final_state = tf.nn.dynamic_rnn(cell, emb_input, initial_state=self.initial_state)\n",
    "            \n",
    "\t\t# =====重新reshape输出=====\n",
    "\t\twith tf.name_scope('output_layer'):\n",
    "\t\t\toutputs = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])\n",
    "\t\t\tw = tf.get_variable('outputs_weight', [HIDDEN_SIZE, VOCAB_SIZE])\n",
    "\t\t\tb = tf.get_variable('outputs_bias', [VOCAB_SIZE])\n",
    "\t\t\tlogits = tf.matmul(outputs, w) + b\n",
    "\n",
    "\t\t# ======计算损失=======\n",
    "\t\twith tf.name_scope('loss'):\n",
    "\t\t\tself.loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example([logits], [tf.reshape(self.targets, [-1])], \n",
    "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t[tf.ones([BATCH_SIZE * TIME_STEPS], dtype=tf.float32)])\n",
    "\t\t\tself.cost = tf.reduce_sum(self.loss) / BATCH_SIZE\n",
    "\n",
    "\t\t# =============优化算法==============\n",
    "\t\twith tf.name_scope('opt'):\n",
    "            # =============学习率衰减==============\n",
    "\t\t\tglobal_step = tf.Variable(0)\n",
    "\t\t\tlearning_rate = tf.train.exponential_decay(learning_rate, global_step, BATCH_NUMS, 0.99, staircase=True)\n",
    "\n",
    "\t\t\t# =======通过clip_by_global_norm()控制梯度大小======\n",
    "\t\t\ttrainable_variables = tf.trainable_variables()\n",
    "\t\t\tgrads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, trainable_variables), MAX_GRAD_NORM)\n",
    "\t\t\tself.opt = tf.train.AdamOptimizer(learning_rate).apply_gradients(zip(grads, trainable_variables))\n",
    "\n",
    "\t\t# ==============预测输出=============\n",
    "\t\twith tf.name_scope('predict'):\n",
    "\t\t\tself.predict = tf.argmax(logits, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 定义训练参数及模型参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# =======预定义模型参数========\n",
    "VOCAB_SIZE = len(vocab)\n",
    "EPOCHS = 1\n",
    "BATCH_SIZE = 8\n",
    "TIME_STEPS = 100\n",
    "BATCH_NUMS = len(numdata) // (BATCH_SIZE * TIME_STEPS)\n",
    "HIDDEN_SIZE = 128\n",
    "HIDDEN_LAYERS = 2\n",
    "MAX_GRAD_NORM = 1\n",
    "learning_rate = 0.003"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 模型训练和保存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Dimensions must be equal, but are 256 and 257 for 'rnn/rnn/while/rnn/multi_rnn_cell/cell_0/lstm_cell/MatMul_1' (op: 'MatMul') with input shapes: [8,256], [257,512].",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\common_shapes.py\u001b[0m in \u001b[0;36m_call_cpp_shape_fn_impl\u001b[1;34m(op, input_tensors_needed, input_tensors_as_shapes_needed, require_shape_fn)\u001b[0m\n\u001b[0;32m    685\u001b[0m           \u001b[0mgraph_def_version\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnode_def_str\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_shapes\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_tensors\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 686\u001b[1;33m           input_tensors_as_shapes, status)\n\u001b[0m\u001b[0;32m    687\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mInvalidArgumentError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\errors_impl.py\u001b[0m in \u001b[0;36m__exit__\u001b[1;34m(self, type_arg, value_arg, traceback_arg)\u001b[0m\n\u001b[0;32m    515\u001b[0m             \u001b[0mcompat\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mas_text\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc_api\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTF_Message\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstatus\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstatus\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 516\u001b[1;33m             c_api.TF_GetCode(self.status.status))\n\u001b[0m\u001b[0;32m    517\u001b[0m     \u001b[1;31m# Delete the underlying status object from memory otherwise it stays alive\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mInvalidArgumentError\u001b[0m: Dimensions must be equal, but are 256 and 257 for 'rnn/rnn/while/rnn/multi_rnn_cell/cell_0/lstm_cell/MatMul_1' (op: 'MatMul') with input shapes: [8,256], [257,512].",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-46632b147f0b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# ===========模型训练===========\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmodel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mRNNModel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mBATCH_SIZE\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mHIDDEN_SIZE\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mHIDDEN_LAYERS\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mVOCAB_SIZE\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlearning_rate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# 保存模型\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0msaver\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSaver\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-9-d783c0656122>\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, BATCH_SIZE, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE, learning_rate)\u001b[0m\n\u001b[0;32m     28\u001b[0m                         \u001b[0mcell\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcontrib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrnn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mMultiRNNCell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mlstm\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mHIDDEN_LAYERS\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m                         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minitial_state\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcell\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzero_state\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mBATCH_SIZE\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloat32\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 30\u001b[1;33m                         \u001b[0moutputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinal_state\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdynamic_rnn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcell\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0memb_input\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minitial_state\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minitial_state\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     31\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m                 \u001b[1;31m# =====重新reshape输出=====\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn.py\u001b[0m in \u001b[0;36mdynamic_rnn\u001b[1;34m(cell, inputs, sequence_length, initial_state, dtype, parallel_iterations, swap_memory, time_major, scope)\u001b[0m\n\u001b[0;32m    633\u001b[0m         \u001b[0mswap_memory\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mswap_memory\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    634\u001b[0m         \u001b[0msequence_length\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msequence_length\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 635\u001b[1;33m         dtype=dtype)\n\u001b[0m\u001b[0;32m    636\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    637\u001b[0m     \u001b[1;31m# Outputs of _dynamic_rnn_loop are always shaped [time, batch, depth].\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn.py\u001b[0m in \u001b[0;36m_dynamic_rnn_loop\u001b[1;34m(cell, inputs, initial_state, parallel_iterations, swap_memory, sequence_length, dtype)\u001b[0m\n\u001b[0;32m    830\u001b[0m       \u001b[0mparallel_iterations\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mparallel_iterations\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    831\u001b[0m       \u001b[0mmaximum_iterations\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtime_steps\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 832\u001b[1;33m       swap_memory=swap_memory)\n\u001b[0m\u001b[0;32m    833\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    834\u001b[0m   \u001b[1;31m# Unpack final output if not using output tuples.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py\u001b[0m in \u001b[0;36mwhile_loop\u001b[1;34m(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations)\u001b[0m\n\u001b[0;32m   3200\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mouter_context\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3201\u001b[0m       \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_to_collection\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mWHILE_CONTEXT\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3202\u001b[1;33m     \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mloop_context\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mBuildLoop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcond\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbody\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloop_vars\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape_invariants\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3203\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mmaximum_iterations\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3204\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py\u001b[0m in \u001b[0;36mBuildLoop\u001b[1;34m(self, pred, body, loop_vars, shape_invariants)\u001b[0m\n\u001b[0;32m   2938\u001b[0m       \u001b[1;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2939\u001b[0m         original_body_result, exit_vars = self._BuildLoop(\n\u001b[1;32m-> 2940\u001b[1;33m             pred, body, original_loop_vars, loop_vars, shape_invariants)\n\u001b[0m\u001b[0;32m   2941\u001b[0m     \u001b[1;32mfinally\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2942\u001b[0m       \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py\u001b[0m in \u001b[0;36m_BuildLoop\u001b[1;34m(self, pred, body, original_loop_vars, loop_vars, shape_invariants)\u001b[0m\n\u001b[0;32m   2875\u001b[0m         flat_sequence=vars_for_body_with_tensor_arrays)\n\u001b[0;32m   2876\u001b[0m     \u001b[0mpre_summaries\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2877\u001b[1;33m     \u001b[0mbody_result\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbody\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mpacked_vars_for_body\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2878\u001b[0m     \u001b[0mpost_summaries\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_collection\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGraphKeys\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_SUMMARY_COLLECTION\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2879\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mnest\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_sequence\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbody_result\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py\u001b[0m in \u001b[0;36m<lambda>\u001b[1;34m(i, lv)\u001b[0m\n\u001b[0;32m   3176\u001b[0m         cond = lambda i, lv: (  # pylint: disable=g-long-lambda\n\u001b[0;32m   3177\u001b[0m             math_ops.logical_and(i < maximum_iterations, orig_cond(*lv)))\n\u001b[1;32m-> 3178\u001b[1;33m         \u001b[0mbody\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlv\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morig_body\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mlv\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3179\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3180\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mcontext\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexecuting_eagerly\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn.py\u001b[0m in \u001b[0;36m_time_step\u001b[1;34m(time, output_ta_t, state)\u001b[0m\n\u001b[0;32m    801\u001b[0m           skip_conditionals=True)\n\u001b[0;32m    802\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 803\u001b[1;33m       \u001b[1;33m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_state\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcall_cell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    804\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    805\u001b[0m     \u001b[1;31m# Pack state if using state tuples\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn.py\u001b[0m in \u001b[0;36m<lambda>\u001b[1;34m()\u001b[0m\n\u001b[0;32m    787\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    788\u001b[0m     \u001b[0minput_t\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnest\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpack_sequence_as\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstructure\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflat_sequence\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minput_t\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 789\u001b[1;33m     \u001b[0mcall_cell\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mcell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_t\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    790\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    791\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0msequence_length\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn_cell_impl.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs, state, scope)\u001b[0m\n\u001b[0;32m    189\u001b[0m         \u001b[0msetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscope_attrname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscope\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    190\u001b[0m       \u001b[1;32mwith\u001b[0m \u001b[0mscope\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 191\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mRNNCell\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    192\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    193\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_rnn_get_variable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgetter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\layers\\base.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs, *args, **kwargs)\u001b[0m\n\u001b[0;32m    712\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    713\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0min_deferred_mode\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 714\u001b[1;33m           \u001b[0moutputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcall\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    715\u001b[0m           \u001b[1;32mif\u001b[0m \u001b[0moutputs\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    716\u001b[0m             raise ValueError('A layer\\'s `call` method should return a Tensor '\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn_cell_impl.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, inputs, state)\u001b[0m\n\u001b[0;32m   1240\u001b[0m                                       [-1, cell.state_size])\n\u001b[0;32m   1241\u001b[0m           \u001b[0mcur_state_pos\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mcell\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstate_size\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1242\u001b[1;33m         \u001b[0mcur_inp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_state\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcur_inp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcur_state\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1243\u001b[0m         \u001b[0mnew_states\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_state\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1244\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn_cell_impl.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs, state, scope)\u001b[0m\n\u001b[0;32m   1056\u001b[0m                              \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_recurrent_input_noise\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1057\u001b[0m                              self._input_keep_prob)\n\u001b[1;32m-> 1058\u001b[1;33m     \u001b[0moutput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_state\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_cell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscope\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mscope\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1059\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0m_should_dropout\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_state_keep_prob\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1060\u001b[0m       \u001b[1;31m# Identify which subsets of the state to perform dropout on and\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn_cell_impl.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs, state, scope, *args, **kwargs)\u001b[0m\n\u001b[0;32m    296\u001b[0m     \u001b[1;31m# method.  See the class docstring for more details.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    297\u001b[0m     return base_layer.Layer.__call__(self, inputs, state, scope=scope,\n\u001b[1;32m--> 298\u001b[1;33m                                      *args, **kwargs)\n\u001b[0m\u001b[0;32m    299\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    300\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\layers\\base.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs, *args, **kwargs)\u001b[0m\n\u001b[0;32m    712\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    713\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0min_deferred_mode\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 714\u001b[1;33m           \u001b[0moutputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcall\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    715\u001b[0m           \u001b[1;32mif\u001b[0m \u001b[0moutputs\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    716\u001b[0m             raise ValueError('A layer\\'s `call` method should return a Tensor '\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\rnn_cell_impl.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(self, inputs, state)\u001b[0m\n\u001b[0;32m    790\u001b[0m     \u001b[1;31m# i = input_gate, j = new_input, f = forget_gate, o = output_gate\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    791\u001b[0m     lstm_matrix = math_ops.matmul(\n\u001b[1;32m--> 792\u001b[1;33m         array_ops.concat([inputs, m_prev], 1), self._kernel)\n\u001b[0m\u001b[0;32m    793\u001b[0m     \u001b[0mlstm_matrix\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnn_ops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias_add\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlstm_matrix\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_bias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    794\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py\u001b[0m in \u001b[0;36mmatmul\u001b[1;34m(a, b, transpose_a, transpose_b, adjoint_a, adjoint_b, a_is_sparse, b_is_sparse, name)\u001b[0m\n\u001b[0;32m   2106\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2107\u001b[0m       return gen_math_ops.mat_mul(\n\u001b[1;32m-> 2108\u001b[1;33m           a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\u001b[0m\u001b[0;32m   2109\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2110\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\gen_math_ops.py\u001b[0m in \u001b[0;36mmat_mul\u001b[1;34m(a, b, transpose_a, transpose_b, name)\u001b[0m\n\u001b[0;32m   4490\u001b[0m     _, _, _op = _op_def_lib._apply_op_helper(\n\u001b[0;32m   4491\u001b[0m         \u001b[1;34m\"MatMul\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtranspose_a\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtranspose_a\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtranspose_b\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtranspose_b\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 4492\u001b[1;33m         name=name)\n\u001b[0m\u001b[0;32m   4493\u001b[0m     \u001b[0m_result\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_op\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   4494\u001b[0m     \u001b[0m_inputs_flat\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_op\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py\u001b[0m in \u001b[0;36m_apply_op_helper\u001b[1;34m(self, op_type_name, name, **keywords)\u001b[0m\n\u001b[0;32m    785\u001b[0m         op = g.create_op(op_type_name, inputs, output_types, name=scope,\n\u001b[0;32m    786\u001b[0m                          \u001b[0minput_types\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minput_types\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mattr_protos\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 787\u001b[1;33m                          op_def=op_def)\n\u001b[0m\u001b[0;32m    788\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0moutput_structure\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mop_def\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_stateful\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mop\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    789\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36mcreate_op\u001b[1;34m(self, op_type, inputs, dtypes, input_types, name, attrs, op_def, compute_shapes, compute_device)\u001b[0m\n\u001b[0;32m   3290\u001b[0m           op_def=op_def)\n\u001b[0;32m   3291\u001b[0m       self._create_op_helper(ret, compute_shapes=compute_shapes,\n\u001b[1;32m-> 3292\u001b[1;33m                              compute_device=compute_device)\n\u001b[0m\u001b[0;32m   3293\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mret\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3294\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36m_create_op_helper\u001b[1;34m(self, op, compute_shapes, compute_device)\u001b[0m\n\u001b[0;32m   3330\u001b[0m     \u001b[1;31m# compute_shapes argument.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3331\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mop\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_c_op\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mcompute_shapes\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3332\u001b[1;33m       \u001b[0mset_shapes_for_outputs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3333\u001b[0m     \u001b[1;31m# TODO(b/XXXX): move to Operation.__init__ once _USE_C_API flag is removed.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3334\u001b[0m     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_add_op\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36mset_shapes_for_outputs\u001b[1;34m(op)\u001b[0m\n\u001b[0;32m   2494\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0m_set_shapes_for_outputs_c_api\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2495\u001b[0m   \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2496\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0m_set_shapes_for_outputs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2497\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2498\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36m_set_shapes_for_outputs\u001b[1;34m(op)\u001b[0m\n\u001b[0;32m   2467\u001b[0m       \u001b[0mshape_func\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_call_cpp_shape_fn_and_require_op\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2468\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2469\u001b[1;33m   \u001b[0mshapes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mshape_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2470\u001b[0m   \u001b[1;32mif\u001b[0m \u001b[0mshapes\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2471\u001b[0m     raise RuntimeError(\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36mcall_with_requiring\u001b[1;34m(op)\u001b[0m\n\u001b[0;32m   2397\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2398\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0mcall_with_requiring\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2399\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mcall_cpp_shape_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mop\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrequire_shape_fn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2400\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2401\u001b[0m   \u001b[0m_call_cpp_shape_fn_and_require_op\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcall_with_requiring\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\common_shapes.py\u001b[0m in \u001b[0;36mcall_cpp_shape_fn\u001b[1;34m(op, require_shape_fn)\u001b[0m\n\u001b[0;32m    625\u001b[0m     res = _call_cpp_shape_fn_impl(op, input_tensors_needed,\n\u001b[0;32m    626\u001b[0m                                   \u001b[0minput_tensors_as_shapes_needed\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 627\u001b[1;33m                                   require_shape_fn)\n\u001b[0m\u001b[0;32m    628\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mres\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    629\u001b[0m       \u001b[1;31m# Handles the case where _call_cpp_shape_fn_impl calls unknown_shape(op).\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\common_shapes.py\u001b[0m in \u001b[0;36m_call_cpp_shape_fn_impl\u001b[1;34m(op, input_tensors_needed, input_tensors_as_shapes_needed, require_shape_fn)\u001b[0m\n\u001b[0;32m    689\u001b[0m       \u001b[0mmissing_shape_fn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    690\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 691\u001b[1;33m       \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmessage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    692\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    693\u001b[0m   \u001b[1;32mif\u001b[0m \u001b[0mmissing_shape_fn\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Dimensions must be equal, but are 256 and 257 for 'rnn/rnn/while/rnn/multi_rnn_cell/cell_0/lstm_cell/MatMul_1' (op: 'MatMul') with input shapes: [8,256], [257,512]."
     ]
    }
   ],
   "source": [
    "# ===========模型训练===========\n",
    "model = RNNModel(BATCH_SIZE, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE, learning_rate)\n",
    "\n",
    "# 保存模型\n",
    "saver = tf.train.Saver()\n",
    "with tf.Session() as sess:\n",
    "\twriter = tf.summary.FileWriter('logs/tensorboard', tf.get_default_graph())\n",
    "\n",
    "\tsess.run(tf.global_variables_initializer())\n",
    "\tfor k in range(EPOCHS):\n",
    "\t\tstate = sess.run(model.initial_state)\n",
    "\t\ttrain_data = data_generator(numdata, BATCH_SIZE, TIME_STEPS)\n",
    "\t\ttotal_loss = 0.\n",
    "\t\tfor i in range(BATCH_NUMS):\n",
    "\t\t\txs, ys = next(train_data)\n",
    "\t\t\tfeed = {model.inputs: xs, model.targets: ys, model.keepprb: 0.8, model.initial_state: state}\n",
    "\t\t\tcosts, state, _ = sess.run([model.cost, model.final_state, model.opt], feed_dict=feed)\n",
    "\t\t\ttotal_loss += costs\n",
    "\t\t\tif (i+1) % 50 == 0:\n",
    "\t\t\t\tprint('epochs:', k + 1, 'iter:', i + 1, 'cost:', total_loss / i + 1)\n",
    "\n",
    "\tsaver.save(sess, './checkpoints/lstm.ckpt')\n",
    "\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 评估准则与效果\n",
    "文本生成的评估准则我们选择loss和文本生成的效果作为评估效果，其他的评估效果我自己确实也不是很了解。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ============模型测试============\n",
    "tf.reset_default_graph()\n",
    "evalmodel = RNNModel(1, HIDDEN_SIZE, HIDDEN_LAYERS, VOCAB_SIZE, learning_rate)\n",
    "# 加载模型\n",
    "saver = tf.train.Saver()\n",
    "with tf.Session() as sess:\n",
    "\tsaver.restore(sess, './checkpoints/lstm.ckpt')\n",
    "\tnew_state = sess.run(evalmodel.initial_state)\n",
    "\tx = np.zeros((1, 1)) + 8\n",
    "\tsamples = []\n",
    "\tfor i in range(100):\n",
    "\t\tfeed = {evalmodel.inputs: x, evalmodel.keepprb: 1., evalmodel.initial_state: new_state}\n",
    "\t\tc, new_state = sess.run([evalmodel.predict, evalmodel.final_state], feed_dict=feed)\n",
    "\t\tx[0][0] = c[0]\n",
    "\t\tsamples.append(c[0])\n",
    "\tprint('test:', ''.join([id2char[index] for index in samples]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 模型的优化与提升\n",
    "我使用的网络结构比较简单，2层lstm，每一层有128个节点，可以看出得到的结果也很一般。\n",
    "模型的优化可以从网络结构和学习率优化上进行提升。电脑能力有限，我选择的网络结构较为简单，可以尝试更深的结构，更多的隐藏层节点数。就能得到更好的结果。\n",
    "\n",
    "- 下面是我用3层，512个节点训练了20个epochs得到的结果：\n",
    "```b\n",
    "着，但我的朋友蓝解放和黄互助，你这个女人，是你的亲生儿子，我们的开放，你是个人，我们的开放，你是个人，我们的开放，你是个人，我们的开放，你是个人，我们的开放，你是个人，我们的开放，你是个人，我们的开放\n",
    "```\n",
    "\n",
    "除此之外，还可以尝试按照词级别对应一个index进行建模方法建模。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import jieba\n",
    "word_data = list(jieba.cut(data))\n",
    "\n",
    "# =====生成字典=====\n",
    "word_vocab = set(word_data)\n",
    "id2word = list(word_vocab)\n",
    "word2id = {c:i for i,c in enumerate(vocab)}\n",
    "\n",
    "print(word_data[:100])\n",
    "print(id2word[:100])\n",
    "print(len(vocab))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
